react-native-jet-markdown 0.2.1 → 0.2.2

package/README.md

@@ -1,9 +1,9 @@
 <p align="center">
-  <img alt="react-native-jet-markdown — native markdown viewer and WYSIWYG editor for React Native" src="https://raw.githubusercontent.com/alizahid/react-native-jet-markdown/main/docs/hero.svg" width="900">
+  <img alt="react-native-jet-markdown — native markdown viewer for React Native" src="https://raw.githubusercontent.com/alizahid/react-native-jet-markdown/main/docs/hero.svg" width="900">
 </p>
 
 <p align="center">
-  Fast, fully native Markdown viewer &amp; WYSIWYG editor for React Native
+  Fast, fully native Markdown viewer for React Native
 </p>
 
 <p align="center">
@@ -150,73 +150,21 @@ Numbers from the shared C++ core (Apple M-series, `-O2`; the same code runs on d
 | --- | --- | --- |
 | Parse a typical feed post | 1.5 KB mixed markdown | **35 µs** |
 | Parse a large document | 160 KB | **4.1 ms** |
-| Open a document in the editor (`editorFromMarkdown`) | 160 KB, ~6,400 style runs | **4.7 ms** |
-| Serialize the editor back to markdown | 160 KB | **5.8 ms** |
 | Serialize the full `defaultStyles` object in JS | 980 B JSON | **3 µs**, memoized |
 
-Beyond raw parsing: measurement runs on the Fabric layout thread (never on main), parse + layout results are cached and shared between measure and mount, editor keystrokes only rebuild the derived styling of the lines they touch, and markdown serialization is coalesced to once per frame. The 500-item Feed screen in the example app scrolls at 60 fps on both platforms.
+Beyond raw parsing: measurement runs on the Fabric layout thread (never on main), and parse + layout results are cached and shared between measure and mount. The 500-item Feed screen in the example app scrolls at 60 fps on both platforms.
 
 ### Why styles cross as JSON
 
 You may notice styles ship natively as one `stylesJson` string instead of a structured object. This is deliberate, not legacy: Fabric props cross via JSI either way (there is no old-bridge serialization in either design), codegen cannot express the open-keyed `mention.variants` map, and the string doubles as the cache key shared by the C++ measurer, iOS, and Android — a structured prop would need deep equality or native re-serialization to get the same caching. The cost is ~3 µs once per distinct styles object.
 
-## Editor
-
-> [!WARNING]
-> The editor is not ready for production use yet. The viewer (`JetMarkdownView`) is stable; `JetMarkdownEditor` still has known issues and its API may change. Track progress in the issue tracker before shipping it.
-
-`JetMarkdownEditor` is a WYSIWYG editor with markdown as the interchange format: no visible syntax while editing, `onChangeMarkdown` fires with serialized markdown on every edit, and `setValue`/`defaultValue`/paste parse markdown into styled content.
-
-```tsx
-import { JetMarkdownEditor, useJetMarkdownEditor } from "react-native-jet-markdown";
-
-function Compose() {
-  const editor = useJetMarkdownEditor();
-
-  return (
-    <>
-      <JetMarkdownEditor
-        mentionTriggers={["@"]}
-        onChangeMarkdown={(markdown) => save(markdown)}
-        onMentionChange={({ query }) => search(query)}
-        placeholder="Write something..."
-        ref={editor.ref}
-      />
-      <Button onPress={editor.toggleBold} title="B" />
-    </>
-  );
-}
-```
-
-### Formatting
-
-Inline marks — bold, italic, strikethrough, inline code, spoiler, superscript, subscript — toggle over the selection, or arm for the text typed next at a collapsed cursor (`toggleBold()`, `toggleItalic()`, `toggleStrikethrough()`, `toggleCode()`, `toggleSpoiler()`, `toggleSuperscript()`, `toggleSubscript()`).
-
-Blocks apply per line: `toggleHeading(1-6)`, `toggleBlockQuote()`, `toggleCodeBlock()`, `toggleUnorderedList()`, `toggleOrderedList()`. Enter continues a list, Enter on an empty item exits it, Enter after a heading returns to paragraph, and backspace at the start of a formatted line clears its block first.
-
-`onChangeState` reports the formatting at the cursor or selection (`isBold`, `headingLevel`, `isUnorderedList`, ...) for toolbar highlighting.
-
-### Links & mentions
-
-`insertLink(url, label?)` links the selection (or inserts a linked label), `removeLink()` strips it. Typing a bare `http(s)://` URL followed by a space emits `onLinkDetected` — call `insertLink` if you want it linkified.
-
-Mentions start when a `mentionTriggers` character is typed at a word start: `onMentionStart` → `onMentionChange` (with the growing query) → `onMentionEnd`. Call `insertMention(trigger, label, url)` — e.g. `("@", "ali", "users://ali")` — to replace the query with an atomic token that deletes as one unit.
-
-### Paste
-
-Paste never inserts directly. `onPaste` receives `{ text?, images?, preventDefault() }` — images are reported (never auto-inserted) with `url`, `width`, `height`. Unless you call `preventDefault()` synchronously, the pasted text is parsed as markdown and inserted styled.
-
-### Everything else
-
-`getMarkdown()` resolves the current markdown; `focus()`, `blur()`, `setSelection(start, end)`, `setValue(markdown)`, and `insertMarkdown(markdown)` do what they say. Hardware keyboards get Cmd+B / Cmd+I (iOS) and Ctrl+B / Ctrl+I (Android). The editor shares the viewer's `style` / `styles` contract — the `base`/`paragraph` cascade drives the root text and `link.color` drives links. The viewer's `gap` is not applied while editing (a text field flows line to line); drive the editing feel with the text styles themselves.
-
 ## Platform notes & limitations
 
 - New Architecture (Fabric) only; React Native 0.86+.
 - `textDecorationStyle`/`textDecorationColor` render fully on iOS; Android draws plain underline/strikethrough.
 - `borderCurve: 'continuous'` is iOS-only.
 - `fontVariant` supports `tabular-nums`, `proportional-nums`, `oldstyle-nums`, `lining-nums`, `small-caps` (font support required).
-- `allowFontScaling` (default `true`) scales all text — including `lineHeight` — with the system font size setting on both components.
+- `allowFontScaling` (default `true`) scales all text — including `lineHeight` — with the system font size setting.
 - Spoilers and inline formatting inside link labels stay literal; spoilers inside table cells are unsupported (the `|` delimiter conflicts).
 - Code blocks render plain monospace (no syntax highlighting).
 

package/android/src/main/cpp/JniBindings.cpp

@@ -12,7 +12,6 @@
 #include <vector>
 
 #include "core/AstSerializer.h"
-#include "core/EditorRuns.h"
 #include "core/Parser.h"
 #include "react/JetMarkdownMeasurer.h"
 
@@ -87,111 +86,6 @@ Java_com_jetmarkdown_JetMarkdownNative_parse(JNIEnv* env, jclass, jbyteArray mar
   return toByteArray(env, bytes.data(), bytes.size());
 }
 
-extern "C" JNIEXPORT jbyteArray JNICALL
-Java_com_jetmarkdown_JetMarkdownNative_markdownFromEditorContent(
-    JNIEnv* env,
-    jclass,
-    jbyteArray text,
-    jintArray runs,
-    jintArray lineBlocks,
-    jintArray linkRanges,
-    jbyteArray linkUrls) {
-  std::vector<jetmarkdown::StyledRun> styledRuns;
-  if (runs != nullptr) {
-    const jsize length = env->GetArrayLength(runs);
-    std::vector<jint> values(static_cast<size_t>(length));
-    if (length > 0) {
-      env->GetIntArrayRegion(runs, 0, length, values.data());
-    }
-    for (jsize i = 0; i + 2 < length; i += 3) {
-      styledRuns.push_back(
-          {static_cast<uint32_t>(values[i]),
-           static_cast<uint32_t>(values[i + 1]),
-           static_cast<uint32_t>(values[i + 2])});
-    }
-  }
-  std::vector<jetmarkdown::EditorLine> lines;
-  if (lineBlocks != nullptr) {
-    const jsize length = env->GetArrayLength(lineBlocks);
-    std::vector<jint> values(static_cast<size_t>(length));
-    if (length > 0) {
-      env->GetIntArrayRegion(lineBlocks, 0, length, values.data());
-    }
-    for (jsize i = 0; i + 1 < length; i += 2) {
-      lines.push_back(
-          {static_cast<jetmarkdown::EditorBlockType>(values[i]),
-           static_cast<uint8_t>(values[i + 1])});
-    }
-  }
-  // Link URLs cross as one newline-joined blob (URLs cannot contain '\n').
-  std::vector<jetmarkdown::LinkRun> links;
-  if (linkRanges != nullptr) {
-    const jsize length = env->GetArrayLength(linkRanges);
-    std::vector<jint> values(static_cast<size_t>(length));
-    if (length > 0) {
-      env->GetIntArrayRegion(linkRanges, 0, length, values.data());
-    }
-    const std::string urls = toStdString(env, linkUrls);
-    size_t urlStart = 0;
-    for (jsize i = 0; i + 1 < length; i += 2) {
-      const size_t urlEnd = urls.find('\n', urlStart);
-      links.push_back(
-          {static_cast<uint32_t>(values[i]),
-           static_cast<uint32_t>(values[i + 1]),
-           urls.substr(urlStart, urlEnd == std::string::npos ? std::string::npos
-                                                             : urlEnd - urlStart)});
-      urlStart = urlEnd == std::string::npos ? urls.size() : urlEnd + 1;
-    }
-  }
-  const std::string result = jetmarkdown::markdownFromEditor(
-      toStdString(env, text), styledRuns, lines, links);
-  return toByteArray(
-      env, reinterpret_cast<const uint8_t*>(result.data()), result.size());
-}
-
-extern "C" JNIEXPORT jbyteArray JNICALL
-Java_com_jetmarkdown_JetMarkdownNative_editorFromMarkdownContent(
-    JNIEnv* env,
-    jclass,
-    jbyteArray markdown) {
-  const jetmarkdown::EditorDocument document =
-      jetmarkdown::editorFromMarkdown(toStdString(env, markdown));
-  // [int32 runCount][runCount x (start, end, flags)][int32 lineCount]
-  // [lineCount x (type, level)][utf8 text], little-endian.
-  std::vector<uint8_t> bytes;
-  bytes.reserve(
-      8 + document.runs.size() * 12 + document.lines.size() * 8 +
-      document.text.size());
-  const auto push32 = [&bytes](uint32_t value) {
-    bytes.push_back(static_cast<uint8_t>(value & 0xFF));
-    bytes.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
-    bytes.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
-    bytes.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
-  };
-  push32(static_cast<uint32_t>(document.runs.size()));
-  for (const jetmarkdown::StyledRun& run : document.runs) {
-    push32(run.start);
-    push32(run.end);
-    push32(run.flags);
-  }
-  push32(static_cast<uint32_t>(document.lines.size()));
-  for (const jetmarkdown::EditorLine& line : document.lines) {
-    push32(static_cast<uint32_t>(line.type));
-    push32(line.level);
-  }
-  push32(static_cast<uint32_t>(document.links.size()));
-  for (const jetmarkdown::LinkRun& link : document.links) {
-    push32(link.start);
-    push32(link.end);
-    push32(static_cast<uint32_t>(link.url.size()));
-  }
-  for (const jetmarkdown::LinkRun& link : document.links) {
-    bytes.insert(bytes.end(), link.url.begin(), link.url.end());
-  }
-  bytes.insert(bytes.end(), document.text.begin(), document.text.end());
-  return toByteArray(env, bytes.data(), bytes.size());
-}
-
 extern "C" JNIEXPORT void JNICALL
 Java_com_jetmarkdown_JetMarkdownNative_installMeasurer(
     JNIEnv* env,

package/android/src/main/java/com/jetmarkdown/JetMarkdownNative.kt

@@ -29,86 +29,7 @@ object JetMarkdownNative {
   }
 
 
-  /** Decoded editor content: text, inline-mark runs, line blocks, links. */
-  class EditorContent(
-    val text: String,
-    /** Flat `[start, end, flags]` triples in UTF-16 offsets. */
-    val runs: IntArray,
-    /** Flat `[type, level]` pairs, one per text line. */
-    val lineBlocks: IntArray,
-    /** Flat `[start, end]` pairs, aligned with [linkUrls]. */
-    val linkRanges: IntArray,
-    val linkUrls: List<String>,
-  )
-
-  /**
-   * Editor: markdown from text + inline-mark runs + per-line blocks +
-   * links. Runs are flat `[start, end, flags]` triples in UTF-16 offsets
-   * (Spannable indices); lineBlocks are `[type, level]` pairs per line;
-   * links are `[start, end]` pairs with URLs joined by '\n'.
-   */
-  fun markdownFromEditor(
-    text: String,
-    runs: IntArray,
-    lineBlocks: IntArray,
-    linkRanges: IntArray = IntArray(0),
-    linkUrls: List<String> = emptyList(),
-  ): String {
-    return markdownFromEditorContent(
-      text.toByteArray(Charsets.UTF_8),
-      runs,
-      lineBlocks,
-      linkRanges,
-      linkUrls.joinToString("\n").toByteArray(Charsets.UTF_8),
-    ).toString(Charsets.UTF_8)
-  }
-
-  /**
-   * Editor: markdown parsed into editor content. The native payload is
-   * `[int32 runCount][triples][int32 lineCount][pairs][int32 linkCount]
-   * [(start, end, urlLen) triples][url bytes][utf8 text]`, little-endian.
-   */
-  fun editorFromMarkdown(markdown: String): EditorContent {
-    val bytes = editorFromMarkdownContent(markdown.toByteArray(Charsets.UTF_8))
-    val buffer = java.nio.ByteBuffer.wrap(bytes).order(java.nio.ByteOrder.LITTLE_ENDIAN)
-    val runs = IntArray(buffer.int * 3)
-    for (i in runs.indices) {
-      runs[i] = buffer.int
-    }
-    val lineBlocks = IntArray(buffer.int * 2)
-    for (i in lineBlocks.indices) {
-      lineBlocks[i] = buffer.int
-    }
-    val linkCount = buffer.int
-    val linkRanges = IntArray(linkCount * 2)
-    val urlLengths = IntArray(linkCount)
-    for (i in 0 until linkCount) {
-      linkRanges[i * 2] = buffer.int
-      linkRanges[i * 2 + 1] = buffer.int
-      urlLengths[i] = buffer.int
-    }
-    val linkUrls = ArrayList<String>(linkCount)
-    for (i in 0 until linkCount) {
-      val urlBytes = ByteArray(urlLengths[i])
-      buffer.get(urlBytes)
-      linkUrls.add(urlBytes.toString(Charsets.UTF_8))
-    }
-    val text = ByteArray(buffer.remaining())
-    buffer.get(text)
-    return EditorContent(text.toString(Charsets.UTF_8), runs, lineBlocks, linkRanges, linkUrls)
-  }
-
   @JvmStatic private external fun parse(markdown: ByteArray): ByteArray
 
-  @JvmStatic private external fun markdownFromEditorContent(
-    text: ByteArray,
-    runs: IntArray,
-    lineBlocks: IntArray,
-    linkRanges: IntArray,
-    linkUrls: ByteArray,
-  ): ByteArray
-
-  @JvmStatic private external fun editorFromMarkdownContent(markdown: ByteArray): ByteArray
-
   @JvmStatic private external fun installMeasurer(measurer: MarkdownMeasurer)
 }

package/android/src/main/java/com/jetmarkdown/JetMarkdownPackage.kt

@@ -5,7 +5,6 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
-import com.jetmarkdown.editor.JetMarkdownEditorManager
 
 class JetMarkdownViewPackage : BaseReactPackage() {
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
@@ -13,7 +12,7 @@ class JetMarkdownViewPackage : BaseReactPackage() {
     // font/color resolution must work from the very first measure. The view
     // managers re-install with the themed context on view creation.
     com.jetmarkdown.style.PlatformColorResolver.install(reactContext)
-    return listOf(JetMarkdownViewManager(), JetMarkdownEditorManager())
+    return listOf(JetMarkdownViewManager())
   }
 
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null

package/android/src/main/java/com/jetmarkdown/render/spans/MarkdownLineHeightSpan.kt

@@ -1,26 +1,15 @@
 package com.jetmarkdown.render.spans
 
 import android.graphics.Paint
-import android.text.TextPaint
 import android.text.style.LineHeightSpan
-import android.text.style.MetricAffectingSpan
 import kotlin.math.ceil
 import kotlin.math.floor
 
 /**
  * React Native's lineHeight semantics: the line box is exactly [heightPx]
- * tall with glyphs centered (mirrors RN's CustomLineHeightSpan). Extends
- * MetricAffectingSpan (a no-op there) so DynamicLayout — the editor —
- * reflows when the span is attached; plain LineHeightSpan is not an
- * UpdateLayout span.
+ * tall with glyphs centered (mirrors RN's CustomLineHeightSpan).
  */
-open class MarkdownLineHeightSpan(private val heightPx: Int) :
-  MetricAffectingSpan(),
-  LineHeightSpan {
-  override fun updateMeasureState(paint: TextPaint) = Unit
-
-  override fun updateDrawState(paint: TextPaint) = Unit
-
+class MarkdownLineHeightSpan(private val heightPx: Int) : LineHeightSpan {
   override fun chooseHeight(
     text: CharSequence,
     start: Int,

package/cpp/react/override/react/renderer/components/JetMarkdownViewSpec/ComponentDescriptors.h

@@ -7,7 +7,6 @@
 
 #include <react/renderer/core/ConcreteComponentDescriptor.h>
 
-#include "../../../../../JetMarkdownEditorShadowNode.h"
 #include "../../../../../JetMarkdownShadowNode.h"
 
 namespace facebook::react {
@@ -15,7 +14,4 @@ namespace facebook::react {
 using JetMarkdownViewComponentDescriptor =
     ConcreteComponentDescriptor<JetMarkdownShadowNode>;
 
-using JetMarkdownEditorComponentDescriptor =
-    ConcreteComponentDescriptor<JetMarkdownEditorShadowNode>;
-
 } // namespace facebook::react